<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP, RankNTypes, MagicHash, BangPatterns #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span class="hs-cpp">

#if defined(__GLASGOW_HASKELL__) &amp;&amp; !defined(__HADDOCK__)
</span><span class="hs-cpp">#include &quot;MachDeps.h&quot;
</span><span class="hs-cpp">#endif
</span><span>
</span><span id="line-8"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Module      : Data.Binary.Get</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Copyright   : Lennart Kolmodin</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- License     : BSD3-style (see LICENSE)</span><span>
</span><span id="line-13"></span><span class="hs-comment">--</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- Maintainer  : Lennart Kolmodin &lt;kolmodin@gmail.com&gt;</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- Stability   : experimental</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- Portability : portable to Hugs and GHC.</span><span>
</span><span id="line-17"></span><span class="hs-comment">--</span><span>
</span><span id="line-18"></span><span class="hs-comment">-- The 'Get' monad. A monad for efficiently building structures from</span><span>
</span><span id="line-19"></span><span class="hs-comment">-- encoded lazy ByteStrings.</span><span>
</span><span id="line-20"></span><span class="hs-comment">--</span><span>
</span><span id="line-21"></span><span class="hs-comment">-- Primitives are available to decode words of various sizes, both big and</span><span>
</span><span id="line-22"></span><span class="hs-comment">-- little endian.</span><span>
</span><span id="line-23"></span><span class="hs-comment">--</span><span>
</span><span id="line-24"></span><span class="hs-comment">-- Let's decode binary data representing illustrated here.</span><span>
</span><span id="line-25"></span><span class="hs-comment">-- In this example the values are in little endian.</span><span>
</span><span id="line-26"></span><span class="hs-comment">--</span><span>
</span><span id="line-27"></span><span class="hs-comment">-- &gt; +------------------+--------------+-----------------+</span><span>
</span><span id="line-28"></span><span class="hs-comment">-- &gt; | 32 bit timestamp | 32 bit price | 16 bit quantity |</span><span>
</span><span id="line-29"></span><span class="hs-comment">-- &gt; +------------------+--------------+-----------------+</span><span>
</span><span id="line-30"></span><span class="hs-comment">--</span><span>
</span><span id="line-31"></span><span class="hs-comment">-- A corresponding Haskell value looks like this:</span><span>
</span><span id="line-32"></span><span class="hs-comment">--</span><span>
</span><span id="line-33"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-34"></span><span class="hs-comment">--data Trade = Trade</span><span>
</span><span id="line-35"></span><span class="hs-comment">--  { timestamp :: !'Word32'</span><span>
</span><span id="line-36"></span><span class="hs-comment">--  , price     :: !'Word32'</span><span>
</span><span id="line-37"></span><span class="hs-comment">--  , qty       :: !'Word16'</span><span>
</span><span id="line-38"></span><span class="hs-comment">--  } deriving ('Show')</span><span>
</span><span id="line-39"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-40"></span><span class="hs-comment">--</span><span>
</span><span id="line-41"></span><span class="hs-comment">-- The fields in @Trade@ are marked as strict (using @!@) since we don't need</span><span>
</span><span id="line-42"></span><span class="hs-comment">-- laziness here. In practise, you would probably consider using the UNPACK</span><span>
</span><span id="line-43"></span><span class="hs-comment">-- pragma as well.</span><span>
</span><span id="line-44"></span><span class="hs-comment">-- &lt;https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#unpack-pragma&gt;</span><span>
</span><span id="line-45"></span><span class="hs-comment">--</span><span>
</span><span id="line-46"></span><span class="hs-comment">-- Now, let's have a look at a decoder for this format.</span><span>
</span><span id="line-47"></span><span class="hs-comment">--</span><span>
</span><span id="line-48"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-49"></span><span class="hs-comment">--getTrade :: 'Get' Trade</span><span>
</span><span id="line-50"></span><span class="hs-comment">--getTrade = do</span><span>
</span><span id="line-51"></span><span class="hs-comment">--  timestamp &lt;- 'getWord32le'</span><span>
</span><span id="line-52"></span><span class="hs-comment">--  price     &lt;- 'getWord32le'</span><span>
</span><span id="line-53"></span><span class="hs-comment">--  quantity  &lt;- 'getWord16le'</span><span>
</span><span id="line-54"></span><span class="hs-comment">--  return '$!' Trade timestamp price quantity</span><span>
</span><span id="line-55"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-56"></span><span class="hs-comment">--</span><span>
</span><span id="line-57"></span><span class="hs-comment">-- Or even simpler using applicative style:</span><span>
</span><span id="line-58"></span><span class="hs-comment">--</span><span>
</span><span id="line-59"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-60"></span><span class="hs-comment">--getTrade' :: 'Get' Trade</span><span>
</span><span id="line-61"></span><span class="hs-comment">--getTrade' = Trade '&lt;$&gt;' 'getWord32le' '&lt;*&gt;' 'getWord32le' '&lt;*&gt;' 'getWord16le'</span><span>
</span><span id="line-62"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-63"></span><span class="hs-comment">--</span><span>
</span><span id="line-64"></span><span class="hs-comment">-- There are two kinds of ways to execute this decoder, the lazy input</span><span>
</span><span id="line-65"></span><span class="hs-comment">-- method and the incremental input method. Here we will use the lazy</span><span>
</span><span id="line-66"></span><span class="hs-comment">-- input method.</span><span>
</span><span id="line-67"></span><span class="hs-comment">--</span><span>
</span><span id="line-68"></span><span class="hs-comment">-- Let's first define a function that decodes many @Trade@s.</span><span>
</span><span id="line-69"></span><span class="hs-comment">--</span><span>
</span><span id="line-70"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-71"></span><span class="hs-comment">--getTrades :: Get [Trade]</span><span>
</span><span id="line-72"></span><span class="hs-comment">--getTrades = do</span><span>
</span><span id="line-73"></span><span class="hs-comment">--  empty &lt;- 'isEmpty'</span><span>
</span><span id="line-74"></span><span class="hs-comment">--  if empty</span><span>
</span><span id="line-75"></span><span class="hs-comment">--    then return []</span><span>
</span><span id="line-76"></span><span class="hs-comment">--    else do trade &lt;- getTrade</span><span>
</span><span id="line-77"></span><span class="hs-comment">--            trades &lt;- getTrades</span><span>
</span><span id="line-78"></span><span class="hs-comment">--            return (trade:trades)</span><span>
</span><span id="line-79"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-80"></span><span class="hs-comment">--</span><span>
</span><span id="line-81"></span><span class="hs-comment">-- Finally, we run the decoder:</span><span>
</span><span id="line-82"></span><span class="hs-comment">--</span><span>
</span><span id="line-83"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-84"></span><span class="hs-comment">--lazyIOExample :: IO [Trade]</span><span>
</span><span id="line-85"></span><span class="hs-comment">--lazyIOExample = do</span><span>
</span><span id="line-86"></span><span class="hs-comment">--  input &lt;- BL.readFile \&quot;trades.bin\&quot;</span><span>
</span><span id="line-87"></span><span class="hs-comment">--  return ('runGet' getTrades input)</span><span>
</span><span id="line-88"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-89"></span><span class="hs-comment">--</span><span>
</span><span id="line-90"></span><span class="hs-comment">-- This decoder has the downside that it will need to read all the input before</span><span>
</span><span id="line-91"></span><span class="hs-comment">-- it can return. On the other hand, it will not return anything until</span><span>
</span><span id="line-92"></span><span class="hs-comment">-- it knows it could decode without any decoder errors.</span><span>
</span><span id="line-93"></span><span class="hs-comment">--</span><span>
</span><span id="line-94"></span><span class="hs-comment">-- You could also refactor to a left-fold, to decode in a more streaming fashion,</span><span>
</span><span id="line-95"></span><span class="hs-comment">-- and get the following decoder. It will start to return data without knowing</span><span>
</span><span id="line-96"></span><span class="hs-comment">-- that it can decode all input.</span><span>
</span><span id="line-97"></span><span class="hs-comment">--</span><span>
</span><span id="line-98"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-99"></span><span class="hs-comment">--incrementalExample :: BL.ByteString -&gt; [Trade]</span><span>
</span><span id="line-100"></span><span class="hs-comment">--incrementalExample input0 = go decoder input0</span><span>
</span><span id="line-101"></span><span class="hs-comment">--  where</span><span>
</span><span id="line-102"></span><span class="hs-comment">--    decoder = 'runGetIncremental' getTrade</span><span>
</span><span id="line-103"></span><span class="hs-comment">--    go :: 'Decoder' Trade -&gt; BL.ByteString -&gt; [Trade]</span><span>
</span><span id="line-104"></span><span class="hs-comment">--    go ('Done' leftover _consumed trade) input =</span><span>
</span><span id="line-105"></span><span class="hs-comment">--      trade : go decoder (BL.chunk leftover input)</span><span>
</span><span id="line-106"></span><span class="hs-comment">--    go ('Partial' k) input                     =</span><span>
</span><span id="line-107"></span><span class="hs-comment">--      go (k . takeHeadChunk $ input) (dropHeadChunk input)</span><span>
</span><span id="line-108"></span><span class="hs-comment">--    go ('Fail' _leftover _consumed msg) _input =</span><span>
</span><span id="line-109"></span><span class="hs-comment">--      error msg</span><span>
</span><span id="line-110"></span><span class="hs-comment">--</span><span>
</span><span id="line-111"></span><span class="hs-comment">--takeHeadChunk :: BL.ByteString -&gt; Maybe BS.ByteString</span><span>
</span><span id="line-112"></span><span class="hs-comment">--takeHeadChunk lbs =</span><span>
</span><span id="line-113"></span><span class="hs-comment">--  case lbs of</span><span>
</span><span id="line-114"></span><span class="hs-comment">--    (BL.Chunk bs _) -&gt; Just bs</span><span>
</span><span id="line-115"></span><span class="hs-comment">--    _ -&gt; Nothing</span><span>
</span><span id="line-116"></span><span class="hs-comment">--</span><span>
</span><span id="line-117"></span><span class="hs-comment">--dropHeadChunk :: BL.ByteString -&gt; BL.ByteString</span><span>
</span><span id="line-118"></span><span class="hs-comment">--dropHeadChunk lbs =</span><span>
</span><span id="line-119"></span><span class="hs-comment">--  case lbs of</span><span>
</span><span id="line-120"></span><span class="hs-comment">--    (BL.Chunk _ lbs') -&gt; lbs'</span><span>
</span><span id="line-121"></span><span class="hs-comment">--    _ -&gt; BL.Empty</span><span>
</span><span id="line-122"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-123"></span><span class="hs-comment">--</span><span>
</span><span id="line-124"></span><span class="hs-comment">-- The @lazyIOExample@ uses lazy I/O to read the file from the disk, which is</span><span>
</span><span id="line-125"></span><span class="hs-comment">-- not suitable in all applications, and certainly not if you need to read</span><span>
</span><span id="line-126"></span><span class="hs-comment">-- from a socket which has higher likelihood to fail. To address these needs,</span><span>
</span><span id="line-127"></span><span class="hs-comment">-- use the incremental input method like in @incrementalExample@.</span><span>
</span><span id="line-128"></span><span class="hs-comment">-- For an example of how to read incrementally from a Handle,</span><span>
</span><span id="line-129"></span><span class="hs-comment">-- see the implementation of 'Data.Binary.decodeFileOrFail'.</span><span>
</span><span id="line-130"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-131"></span><span>
</span><span id="line-132"></span><span>
</span><span id="line-133"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Binary.Get</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-134"></span><span>
</span><span id="line-135"></span><span>    </span><span class="annot"><span class="hs-comment">-- * The Get monad</span></span><span>
</span><span id="line-136"></span><span>      </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier">Get</span></a></span><span>
</span><span id="line-137"></span><span>
</span><span id="line-138"></span><span>    </span><span class="annot"><span class="hs-comment">-- * The lazy input interface</span></span><span>
</span><span id="line-139"></span><span>    </span><span class="annot"><span class="hs-comment">-- $lazyinterface</span></span><span>
</span><span id="line-140"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#runGet"><span class="hs-identifier">runGet</span></a></span><span>
</span><span id="line-141"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#runGetOrFail"><span class="hs-identifier">runGetOrFail</span></a></span><span>
</span><span id="line-142"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier">ByteOffset</span></a></span><span>
</span><span id="line-143"></span><span>
</span><span id="line-144"></span><span>    </span><span class="annot"><span class="hs-comment">-- * The incremental input interface</span></span><span>
</span><span id="line-145"></span><span>    </span><span class="annot"><span class="hs-comment">-- $incrementalinterface</span></span><span>
</span><span id="line-146"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier">Decoder</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-147"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier">runGetIncremental</span></a></span><span>
</span><span id="line-148"></span><span>
</span><span id="line-149"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Providing input</span></span><span>
</span><span id="line-150"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#pushChunk"><span class="hs-identifier">pushChunk</span></a></span><span>
</span><span id="line-151"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#pushChunks"><span class="hs-identifier">pushChunks</span></a></span><span>
</span><span id="line-152"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#pushEndOfInput"><span class="hs-identifier">pushEndOfInput</span></a></span><span>
</span><span id="line-153"></span><span>
</span><span id="line-154"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Decoding</span></span><span>
</span><span id="line-155"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#skip"><span class="hs-identifier">skip</span></a></span><span>
</span><span id="line-156"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#isEmpty"><span class="hs-identifier">isEmpty</span></a></span><span>
</span><span id="line-157"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#bytesRead"><span class="hs-identifier">bytesRead</span></a></span><span>
</span><span id="line-158"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#isolate"><span class="hs-identifier">isolate</span></a></span><span>
</span><span id="line-159"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#lookAhead"><span class="hs-identifier">lookAhead</span></a></span><span>
</span><span id="line-160"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#lookAheadM"><span class="hs-identifier">lookAheadM</span></a></span><span>
</span><span id="line-161"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#lookAheadE"><span class="hs-identifier">lookAheadE</span></a></span><span>
</span><span id="line-162"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#label"><span class="hs-identifier">label</span></a></span><span>
</span><span id="line-163"></span><span>
</span><span id="line-164"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** ByteStrings</span></span><span>
</span><span id="line-165"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#getByteString"><span class="hs-identifier">getByteString</span></a></span><span>
</span><span id="line-166"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getLazyByteString"><span class="hs-identifier">getLazyByteString</span></a></span><span>
</span><span id="line-167"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getLazyByteStringNul"><span class="hs-identifier">getLazyByteStringNul</span></a></span><span>
</span><span id="line-168"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getRemainingLazyByteString"><span class="hs-identifier">getRemainingLazyByteString</span></a></span><span>
</span><span id="line-169"></span><span>
</span><span id="line-170"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Decoding Words</span></span><span>
</span><span id="line-171"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier">getWord8</span></a></span><span>
</span><span id="line-172"></span><span>
</span><span id="line-173"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Big-endian decoding</span></span><span>
</span><span id="line-174"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16be"><span class="hs-identifier">getWord16be</span></a></span><span>
</span><span id="line-175"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier">getWord32be</span></a></span><span>
</span><span id="line-176"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier">getWord64be</span></a></span><span>
</span><span id="line-177"></span><span>
</span><span id="line-178"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Little-endian decoding</span></span><span>
</span><span id="line-179"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16le"><span class="hs-identifier">getWord16le</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32le"><span class="hs-identifier">getWord32le</span></a></span><span>
</span><span id="line-181"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64le"><span class="hs-identifier">getWord64le</span></a></span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Host-endian, unaligned decoding</span></span><span>
</span><span id="line-184"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWordhost"><span class="hs-identifier">getWordhost</span></a></span><span>
</span><span id="line-185"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16host"><span class="hs-identifier">getWord16host</span></a></span><span>
</span><span id="line-186"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32host"><span class="hs-identifier">getWord32host</span></a></span><span>
</span><span id="line-187"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64host"><span class="hs-identifier">getWord64host</span></a></span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Decoding Ints</span></span><span>
</span><span id="line-190"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt8"><span class="hs-identifier">getInt8</span></a></span><span>
</span><span id="line-191"></span><span>
</span><span id="line-192"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Big-endian decoding</span></span><span>
</span><span id="line-193"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16be"><span class="hs-identifier">getInt16be</span></a></span><span>
</span><span id="line-194"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32be"><span class="hs-identifier">getInt32be</span></a></span><span>
</span><span id="line-195"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64be"><span class="hs-identifier">getInt64be</span></a></span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Little-endian decoding</span></span><span>
</span><span id="line-198"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16le"><span class="hs-identifier">getInt16le</span></a></span><span>
</span><span id="line-199"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32le"><span class="hs-identifier">getInt32le</span></a></span><span>
</span><span id="line-200"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64le"><span class="hs-identifier">getInt64le</span></a></span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Host-endian, unaligned decoding</span></span><span>
</span><span id="line-203"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInthost"><span class="hs-identifier">getInthost</span></a></span><span>
</span><span id="line-204"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16host"><span class="hs-identifier">getInt16host</span></a></span><span>
</span><span id="line-205"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32host"><span class="hs-identifier">getInt32host</span></a></span><span>
</span><span id="line-206"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64host"><span class="hs-identifier">getInt64host</span></a></span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Decoding Floats/Doubles</span></span><span>
</span><span id="line-209"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloatbe"><span class="hs-identifier">getFloatbe</span></a></span><span>
</span><span id="line-210"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloatle"><span class="hs-identifier">getFloatle</span></a></span><span>
</span><span id="line-211"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloathost"><span class="hs-identifier">getFloathost</span></a></span><span>
</span><span id="line-212"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublebe"><span class="hs-identifier">getDoublebe</span></a></span><span>
</span><span id="line-213"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublele"><span class="hs-identifier">getDoublele</span></a></span><span>
</span><span id="line-214"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublehost"><span class="hs-identifier">getDoublehost</span></a></span><span>
</span><span id="line-215"></span><span>
</span><span id="line-216"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Deprecated functions</span></span><span>
</span><span id="line-217"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#runGetState"><span class="hs-identifier">runGetState</span></a></span><span> </span><span class="hs-comment">-- DEPRECATED</span><span>
</span><span id="line-218"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#remaining"><span class="hs-identifier">remaining</span></a></span><span> </span><span class="hs-comment">-- DEPRECATED</span><span>
</span><span id="line-219"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#getBytes"><span class="hs-identifier">getBytes</span></a></span><span> </span><span class="hs-comment">-- DEPRECATED</span><span>
</span><span id="line-220"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">
#if ! MIN_VERSION_base(4,8,0)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-identifier">Control.Applicative</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-225"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.html#"><span class="hs-identifier">Foreign</span></a></span><span>
</span><span id="line-226"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.html#"><span class="hs-identifier">Data.ByteString</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">B</span></span><span>
</span><span id="line-227"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Unsafe.html#"><span class="hs-identifier">Data.ByteString.Unsafe</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">B</span></span><span>
</span><span id="line-228"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.html#"><span class="hs-identifier">Data.ByteString.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">L</span></span><span>
</span><span id="line-229"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#"><span class="hs-identifier">Data.ByteString.Lazy.Internal</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">L</span></span><span>
</span><span id="line-230"></span><span>
</span><span id="line-231"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html"><span class="hs-identifier">Data.Binary.Get.Internal</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Decoder"><span class="hs-identifier">Decoder</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#runGetIncremental"><span class="hs-identifier">runGetIncremental</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-232"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html"><span class="hs-identifier">Data.Binary.Get.Internal</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">I</span></span><span class="hs-cpp">

#if defined(__GLASGOW_HASKELL__) &amp;&amp; !defined(__HADDOCK__)
</span><span class="hs-comment">-- needed for (# unboxing #) with magic hash</span><span>
</span><span id="line-236"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#"><span class="hs-identifier">GHC.Base</span></a></span><span>
</span><span id="line-237"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#"><span class="hs-identifier">GHC.Word</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-240"></span><span class="hs-comment">-- needed for casting words to float/double</span><span>
</span><span id="line-241"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Binary.FloatCast.html"><span class="hs-identifier">Data.Binary.FloatCast</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.FloatCast.html#wordToFloat"><span class="hs-identifier">wordToFloat</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.FloatCast.html#wordToDouble"><span class="hs-identifier">wordToDouble</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-242"></span><span>
</span><span id="line-243"></span><span class="hs-comment">-- $lazyinterface</span><span>
</span><span id="line-244"></span><span class="hs-comment">-- The lazy interface consumes a single lazy 'L.ByteString'. It's the easiest</span><span>
</span><span id="line-245"></span><span class="hs-comment">-- interface to get started with, but it doesn't support interleaving I\/O and</span><span>
</span><span id="line-246"></span><span class="hs-comment">-- parsing, unless lazy I/O is used.</span><span>
</span><span id="line-247"></span><span class="hs-comment">--</span><span>
</span><span id="line-248"></span><span class="hs-comment">-- There is no way to provide more input other than the initial data. To be</span><span>
</span><span id="line-249"></span><span class="hs-comment">-- able to incrementally give more data, see the incremental input interface.</span><span>
</span><span id="line-250"></span><span>
</span><span id="line-251"></span><span class="hs-comment">-- $incrementalinterface</span><span>
</span><span id="line-252"></span><span class="hs-comment">-- The incremental interface gives you more control over how input is</span><span>
</span><span id="line-253"></span><span class="hs-comment">-- provided during parsing. This lets you e.g. interleave parsing and</span><span>
</span><span id="line-254"></span><span class="hs-comment">-- I\/O.</span><span>
</span><span id="line-255"></span><span class="hs-comment">--</span><span>
</span><span id="line-256"></span><span class="hs-comment">-- The incremental interface consumes a strict 'B.ByteString' at a time, each</span><span>
</span><span id="line-257"></span><span class="hs-comment">-- being part of the total amount of input. If your decoder needs more input to</span><span>
</span><span id="line-258"></span><span class="hs-comment">-- finish it will return a 'Partial' with a continuation.</span><span>
</span><span id="line-259"></span><span class="hs-comment">-- If there is no more input, provide it 'Nothing'.</span><span>
</span><span id="line-260"></span><span class="hs-comment">--</span><span>
</span><span id="line-261"></span><span class="hs-comment">-- 'Fail' will be returned if it runs into an error, together with a message,</span><span>
</span><span id="line-262"></span><span class="hs-comment">-- the position and the remaining input.</span><span>
</span><span id="line-263"></span><span class="hs-comment">-- If it succeeds it will return 'Done' with the resulting value,</span><span>
</span><span id="line-264"></span><span class="hs-comment">-- the position and the remaining input.</span><span>
</span><span id="line-265"></span><span>
</span><span id="line-266"></span><span class="hs-comment">-- | A decoder procuced by running a 'Get' monad.</span><span>
</span><span id="line-267"></span><span class="hs-keyword">data</span><span> </span><span id="Decoder"><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-var">Decoder</span></a></span></span><span> </span><span id="local-6989586621679055832"><span class="annot"><a href="#local-6989586621679055832"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Fail"><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-var">Fail</span></a></span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-268"></span><span>              </span><span class="hs-comment">-- ^ The decoder ran into an error. The decoder either used</span><span>
</span><span id="line-269"></span><span>              </span><span class="hs-comment">-- 'fail' or was not provided enough input. Contains any</span><span>
</span><span id="line-270"></span><span>              </span><span class="hs-comment">-- unconsumed input and the number of bytes consumed.</span><span>
</span><span id="line-271"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Partial"><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-var">Partial</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055832"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-272"></span><span>              </span><span class="hs-comment">-- ^ The decoder has consumed the available input and needs</span><span>
</span><span id="line-273"></span><span>              </span><span class="hs-comment">-- more to continue. Provide 'Just' if more input is available</span><span>
</span><span id="line-274"></span><span>              </span><span class="hs-comment">-- and 'Nothing' otherwise, and you will get a new 'Decoder'.</span><span>
</span><span id="line-275"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Done"><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-var">Done</span></a></span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055832"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-276"></span><span>              </span><span class="hs-comment">-- ^ The decoder has successfully finished. Except for the</span><span>
</span><span id="line-277"></span><span>              </span><span class="hs-comment">-- output value you also get any unused input as well as the</span><span>
</span><span id="line-278"></span><span>              </span><span class="hs-comment">-- number of bytes consumed.</span><span>
</span><span id="line-279"></span><span>
</span><span id="line-280"></span><span class="hs-comment">-- | Run a 'Get' monad. See 'Decoder' for what to do next, like providing</span><span>
</span><span id="line-281"></span><span class="hs-comment">-- input, handling decoder errors and to get the output value.</span><span>
</span><span id="line-282"></span><span class="hs-comment">-- Hint: Use the helper functions 'pushChunk', 'pushChunks' and</span><span>
</span><span id="line-283"></span><span class="hs-comment">-- 'pushEndOfInput'.</span><span>
</span><span id="line-284"></span><span id="local-6989586621679055844"><span class="annot"><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier hs-type">runGetIncremental</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055844"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055844"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-285"></span><span id="runGetIncremental"><span class="annot"><span class="annottext">runGetIncremental :: forall a. Get a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier hs-var hs-var">runGetIncremental</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; Decoder a
forall a. Decoder a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#calculateOffset"><span class="hs-identifier hs-var">calculateOffset</span></a></span><span> </span><span class="annot"><span class="annottext">(Decoder a -&gt; Decoder a)
-&gt; (Get a -&gt; Decoder a) -&gt; Get a -&gt; Decoder a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Get a -&gt; Decoder a
forall a. Get a -&gt; Decoder a
</span><a href="Data.Binary.Get.Internal.html#runGetIncremental"><span class="hs-identifier hs-var">I.runGetIncremental</span></a></span><span>
</span><span id="line-286"></span><span>
</span><span id="line-287"></span><span id="local-6989586621679055840"><span class="annot"><a href="Data.Binary.Get.html#calculateOffset"><span class="hs-identifier hs-type">calculateOffset</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Decoder"><span class="hs-identifier hs-type">I.Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055840"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055840"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-288"></span><span id="calculateOffset"><span class="annot"><span class="annottext">calculateOffset :: forall a. Decoder a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#calculateOffset"><span class="hs-identifier hs-var hs-var">calculateOffset</span></a></span></span><span> </span><span id="local-6989586621679055541"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055541"><span class="hs-identifier hs-var">r0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; Int64 -&gt; Decoder a
forall {a}. Decoder a -&gt; Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055540"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055541"><span class="hs-identifier hs-var">r0</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><span class="hs-number">0</span></span><span>
</span><span id="line-289"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-290"></span><span>  </span><span id="local-6989586621679055540"><span class="annot"><span class="annottext">go :: Decoder a -&gt; Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055540"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679055529"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055529"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679055528"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055529"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-291"></span><span>                </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Done"><span class="hs-identifier hs-type">I.Done</span></a></span><span> </span><span id="local-6989586621679055526"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055526"><span class="hs-identifier hs-var">inp</span></a></span></span><span> </span><span id="local-6989586621679055525"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055525"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-var">Done</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055526"><span class="hs-identifier hs-var">inp</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055526"><span class="hs-identifier hs-var">inp</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055525"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-292"></span><span>                </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Fail"><span class="hs-identifier hs-type">I.Fail</span></a></span><span> </span><span id="local-6989586621679055522"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055522"><span class="hs-identifier hs-var">inp</span></a></span></span><span> </span><span id="local-6989586621679055521"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055521"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-var">Fail</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055522"><span class="hs-identifier hs-var">inp</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055522"><span class="hs-identifier hs-var">inp</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055521"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-293"></span><span>                </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Partial"><span class="hs-identifier hs-type">I.Partial</span></a></span><span> </span><span id="local-6989586621679055519"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055519"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-294"></span><span>                    </span><span class="annot"><span class="annottext">(Maybe ByteString -&gt; Decoder a) -&gt; Decoder a
forall a. (Maybe ByteString -&gt; Decoder a) -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-var">Partial</span></a></span><span> </span><span class="annot"><span class="annottext">((Maybe ByteString -&gt; Decoder a) -&gt; Decoder a)
-&gt; (Maybe ByteString -&gt; Decoder a) -&gt; Decoder a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055518"><span class="annot"><span class="annottext">Maybe ByteString
</span><a href="#local-6989586621679055518"><span class="hs-identifier hs-var">ms</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-295"></span><span>                      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Maybe ByteString
</span><a href="#local-6989586621679055518"><span class="hs-identifier hs-var">ms</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-296"></span><span>                        </span><span class="annot"><span class="annottext">Maybe ByteString
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055540"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055519"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ByteString
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span>
</span><span id="line-297"></span><span>                        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679055517"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055517"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055540"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055519"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ByteString
</span><a href="#local-6989586621679055518"><span class="hs-identifier hs-var">ms</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055517"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-298"></span><span>                </span><span class="annot"><a href="Data.Binary.Get.Internal.html#BytesRead"><span class="hs-identifier hs-type">I.BytesRead</span></a></span><span> </span><span id="local-6989586621679055514"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055514"><span class="hs-identifier hs-var">unused</span></a></span></span><span> </span><span id="local-6989586621679055513"><span class="annot"><span class="annottext">Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055513"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-299"></span><span>                    </span><span class="annot"><span class="annottext">Decoder a -&gt; Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055540"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64 -&gt; Decoder a
</span><a href="#local-6989586621679055513"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">(Int64 -&gt; Decoder a) -&gt; Int64 -&gt; Decoder a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055514"><span class="hs-identifier hs-var">unused</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055528"><span class="hs-identifier hs-var">acc</span></a></span><span>
</span><span id="line-300"></span><span>
</span><span id="line-301"></span><span class="hs-comment">-- | DEPRECATED. Provides compatibility with previous versions of this library.</span><span>
</span><span id="line-302"></span><span class="hs-comment">-- Run a 'Get' monad and return a tuple with three values.</span><span>
</span><span id="line-303"></span><span class="hs-comment">-- The first value is the result of the decoder. The second and third are the</span><span>
</span><span id="line-304"></span><span class="hs-comment">-- unused input, and the number of consumed bytes.</span><span>
</span><span id="line-305"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">runGetState</span><span> </span><span class="hs-pragma">&quot;Use runGetIncremental instead. This function will be removed.&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-306"></span><span id="local-6989586621679055824"><span class="annot"><a href="Data.Binary.Get.html#runGetState"><span class="hs-identifier hs-type">runGetState</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055824"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679055824"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-307"></span><span id="runGetState"><span class="annot"><span class="annottext">runGetState :: forall a. Get a -&gt; ByteString -&gt; Int64 -&gt; (a, ByteString, Int64)
</span><a href="Data.Binary.Get.html#runGetState"><span class="hs-identifier hs-var hs-var">runGetState</span></a></span></span><span> </span><span id="local-6989586621679055511"><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055511"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621679055510"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055510"><span class="hs-identifier hs-var">lbs0</span></a></span></span><span> </span><span id="local-6989586621679055509"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055509"><span class="hs-identifier hs-var">pos'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; ByteString -&gt; (a, ByteString, Int64)
forall {a}. Decoder a -&gt; ByteString -&gt; (a, ByteString, Int64)
</span><a href="#local-6989586621679055508"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Get a -&gt; Decoder a
forall a. Get a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier hs-var">runGetIncremental</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055511"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055510"><span class="hs-identifier hs-var">lbs0</span></a></span><span>
</span><span id="line-308"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-309"></span><span>  </span><span id="local-6989586621679055508"><span class="annot"><span class="annottext">go :: Decoder a -&gt; ByteString -&gt; (a, ByteString, Int64)
</span><a href="#local-6989586621679055508"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span id="local-6989586621679055502"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055502"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621679055501"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055501"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055500"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055500"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055499"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055499"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055500"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#chunk"><span class="hs-identifier hs-var">L.chunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055502"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055499"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055501"><span class="hs-identifier hs-var">pos</span></a></span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055509"><span class="hs-identifier hs-var">pos'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-310"></span><span>  </span><span class="annot"><a href="#local-6989586621679055508"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055497"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055497"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055496"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055496"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; ByteString -&gt; (a, ByteString, Int64)
</span><a href="#local-6989586621679055508"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055497"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
</span><a href="Data.Binary.Get.html#takeHeadChunk"><span class="hs-identifier hs-var">takeHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055496"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; ByteString
</span><a href="Data.Binary.Get.html#dropHeadChunk"><span class="hs-identifier hs-var">dropHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055496"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-311"></span><span>  </span><span class="annot"><a href="#local-6989586621679055508"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679055493"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055493"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055492"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055492"><span class="hs-identifier hs-var">msg</span></a></span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-312"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; (a, ByteString, Int64)
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Data.Binary.Get.runGetState at position &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055493"><span class="hs-identifier hs-var">pos</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055492"><span class="hs-identifier hs-var">msg</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-313"></span><span>
</span><span id="line-314"></span><span class="annot"><a href="Data.Binary.Get.html#takeHeadChunk"><span class="hs-identifier hs-type">takeHeadChunk</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span>
</span><span id="line-315"></span><span id="takeHeadChunk"><span class="annot"><span class="annottext">takeHeadChunk :: ByteString -&gt; Maybe ByteString
</span><a href="Data.Binary.Get.html#takeHeadChunk"><span class="hs-identifier hs-var hs-var">takeHeadChunk</span></a></span></span><span> </span><span id="local-6989586621679055489"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055489"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-316"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055489"><span class="hs-identifier hs-var">lbs</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-317"></span><span>    </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#Chunk"><span class="hs-identifier hs-type">L.Chunk</span></a></span><span> </span><span id="local-6989586621679055487"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055487"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055487"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-318"></span><span>    </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe ByteString
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-319"></span><span>
</span><span id="line-320"></span><span class="annot"><a href="Data.Binary.Get.html#dropHeadChunk"><span class="hs-identifier hs-type">dropHeadChunk</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-321"></span><span id="dropHeadChunk"><span class="annot"><span class="annottext">dropHeadChunk :: ByteString -&gt; ByteString
</span><a href="Data.Binary.Get.html#dropHeadChunk"><span class="hs-identifier hs-var hs-var">dropHeadChunk</span></a></span></span><span> </span><span id="local-6989586621679055486"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055486"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-322"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055486"><span class="hs-identifier hs-var">lbs</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-323"></span><span>    </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#Chunk"><span class="hs-identifier hs-type">L.Chunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679055485"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055485"><span class="hs-identifier hs-var">lbs'</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055485"><span class="hs-identifier hs-var">lbs'</span></a></span><span>
</span><span id="line-324"></span><span>    </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#Empty"><span class="hs-identifier hs-var">L.Empty</span></a></span><span>
</span><span id="line-325"></span><span>
</span><span id="line-326"></span><span class="hs-comment">-- | Run a 'Get' monad and return 'Left' on failure and 'Right' on</span><span>
</span><span id="line-327"></span><span class="hs-comment">-- success. In both cases any unconsumed input and the number of bytes</span><span>
</span><span id="line-328"></span><span class="hs-comment">-- consumed is returned. In the case of failure, a human-readable</span><span>
</span><span id="line-329"></span><span class="hs-comment">-- error message is included as well.</span><span>
</span><span id="line-330"></span><span class="hs-comment">--</span><span>
</span><span id="line-331"></span><span class="hs-comment">-- @since 0.6.4.0</span><span>
</span><span id="line-332"></span><span id="local-6989586621679055816"><span class="annot"><a href="Data.Binary.Get.html#runGetOrFail"><span class="hs-identifier hs-type">runGetOrFail</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055816"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-333"></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-type">ByteOffset</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679055816"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-334"></span><span id="runGetOrFail"><span class="annot"><span class="annottext">runGetOrFail :: forall a.
Get a
-&gt; ByteString
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, a)
</span><a href="Data.Binary.Get.html#runGetOrFail"><span class="hs-identifier hs-var hs-var">runGetOrFail</span></a></span></span><span> </span><span id="local-6989586621679055483"><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055483"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621679055482"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055482"><span class="hs-identifier hs-var">lbs0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a
-&gt; ByteString
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, a)
forall {c}.
Decoder c
-&gt; ByteString
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, c)
</span><a href="#local-6989586621679055481"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Get a -&gt; Decoder a
forall a. Get a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier hs-var">runGetIncremental</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055483"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055482"><span class="hs-identifier hs-var">lbs0</span></a></span><span>
</span><span id="line-335"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-336"></span><span>  </span><span id="local-6989586621679055481"><span class="annot"><span class="annottext">feedAll :: Decoder c
-&gt; ByteString
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, c)
</span><a href="#local-6989586621679055481"><span class="hs-identifier hs-var hs-var">feedAll</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span id="local-6989586621679055480"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055480"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span id="local-6989586621679055479"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055479"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055478"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679055478"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055477"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055477"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ByteString, Int64, c)
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, c)
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#chunk"><span class="hs-identifier hs-var">L.chunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055480"><span class="hs-identifier hs-var">bs</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055477"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055479"><span class="hs-identifier hs-var">pos</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679055478"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-337"></span><span>  </span><span class="annot"><a href="#local-6989586621679055481"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055476"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder c
</span><a href="#local-6989586621679055476"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055475"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055475"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder c
-&gt; ByteString
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, c)
</span><a href="#local-6989586621679055481"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder c
</span><a href="#local-6989586621679055476"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
</span><a href="Data.Binary.Get.html#takeHeadChunk"><span class="hs-identifier hs-var">takeHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055475"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; ByteString
</span><a href="Data.Binary.Get.html#dropHeadChunk"><span class="hs-identifier hs-var">dropHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055475"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-338"></span><span>  </span><span class="annot"><a href="#local-6989586621679055481"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span id="local-6989586621679055474"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055474"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679055473"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055473"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055472"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055472"><span class="hs-identifier hs-var">msg</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055471"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055471"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ByteString, Int64, String)
-&gt; Either (ByteString, Int64, String) (ByteString, Int64, c)
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#chunk"><span class="hs-identifier hs-var">L.chunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055474"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055471"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055473"><span class="hs-identifier hs-var">pos</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055472"><span class="hs-identifier hs-var">msg</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-339"></span><span>
</span><span id="line-340"></span><span class="hs-comment">-- | An offset, counted in bytes.</span><span>
</span><span id="line-341"></span><span class="hs-keyword">type</span><span> </span><span id="ByteOffset"><span class="annot"><a href="Data.Binary.Get.html#ByteOffset"><span class="hs-identifier hs-var">ByteOffset</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>
</span><span id="line-342"></span><span>
</span><span id="line-343"></span><span class="hs-comment">-- | The simplest interface to run a 'Get' decoder. If the decoder runs into</span><span>
</span><span id="line-344"></span><span class="hs-comment">-- an error, calls 'fail', or runs out of input, it will call 'error'.</span><span>
</span><span id="line-345"></span><span id="local-6989586621679055811"><span class="annot"><a href="Data.Binary.Get.html#runGet"><span class="hs-identifier hs-type">runGet</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055811"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679055811"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-346"></span><span id="runGet"><span class="annot"><span class="annottext">runGet :: forall a. Get a -&gt; ByteString -&gt; a
</span><a href="Data.Binary.Get.html#runGet"><span class="hs-identifier hs-var hs-var">runGet</span></a></span></span><span> </span><span id="local-6989586621679055470"><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055470"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621679055469"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055469"><span class="hs-identifier hs-var">lbs0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; ByteString -&gt; a
forall {a}. Decoder a -&gt; ByteString -&gt; a
</span><a href="#local-6989586621679055468"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Get a -&gt; Decoder a
forall a. Get a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#runGetIncremental"><span class="hs-identifier hs-var">runGetIncremental</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
</span><a href="#local-6989586621679055470"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055469"><span class="hs-identifier hs-var">lbs0</span></a></span><span>
</span><span id="line-347"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-348"></span><span>  </span><span id="local-6989586621679055468"><span class="annot"><span class="annottext">feedAll :: Decoder a -&gt; ByteString -&gt; a
</span><a href="#local-6989586621679055468"><span class="hs-identifier hs-var hs-var">feedAll</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679055464"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055464"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055464"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-349"></span><span>  </span><span class="annot"><a href="#local-6989586621679055468"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055463"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055463"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055462"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055462"><span class="hs-identifier hs-var">lbs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; ByteString -&gt; a
</span><a href="#local-6989586621679055468"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055463"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
</span><a href="Data.Binary.Get.html#takeHeadChunk"><span class="hs-identifier hs-var">takeHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055462"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; ByteString
</span><a href="Data.Binary.Get.html#dropHeadChunk"><span class="hs-identifier hs-var">dropHeadChunk</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055462"><span class="hs-identifier hs-var">lbs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-350"></span><span>  </span><span class="annot"><a href="#local-6989586621679055468"><span class="hs-identifier hs-var">feedAll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679055461"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055461"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055460"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055460"><span class="hs-identifier hs-var">msg</span></a></span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-351"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; a
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Data.Binary.Get.runGet at position &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055461"><span class="hs-identifier hs-var">pos</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055460"><span class="hs-identifier hs-var">msg</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-352"></span><span>
</span><span id="line-353"></span><span>
</span><span id="line-354"></span><span class="hs-comment">-- | Feed a 'Decoder' with more input. If the 'Decoder' is 'Done' or 'Fail' it</span><span>
</span><span id="line-355"></span><span class="hs-comment">-- will add the input to 'B.ByteString' of unconsumed input.</span><span>
</span><span id="line-356"></span><span class="hs-comment">--</span><span>
</span><span id="line-357"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-358"></span><span class="hs-comment">--    'runGetIncremental' myParser \`pushChunk\` myInput1 \`pushChunk\` myInput2</span><span>
</span><span id="line-359"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-360"></span><span id="local-6989586621679055808"><span class="annot"><a href="Data.Binary.Get.html#pushChunk"><span class="hs-identifier hs-type">pushChunk</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055808"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055808"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-361"></span><span id="pushChunk"><span class="annot"><span class="annottext">pushChunk :: forall a. Decoder a -&gt; ByteString -&gt; Decoder a
</span><a href="Data.Binary.Get.html#pushChunk"><span class="hs-identifier hs-var hs-var">pushChunk</span></a></span></span><span> </span><span id="local-6989586621679055459"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055459"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679055458"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055458"><span class="hs-identifier hs-var">inp</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-362"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055459"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-363"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span id="local-6989586621679055457"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055457"><span class="hs-identifier hs-var">inp0</span></a></span></span><span> </span><span id="local-6989586621679055456"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055456"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679055455"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055455"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-var">Done</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055457"><span class="hs-identifier hs-var">inp0</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.html#append"><span class="hs-operator hs-var">`B.append`</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055458"><span class="hs-identifier hs-var">inp</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055456"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055455"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-364"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055453"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055453"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055453"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055458"><span class="hs-identifier hs-var">inp</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-365"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span id="local-6989586621679055452"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055452"><span class="hs-identifier hs-var">inp0</span></a></span></span><span> </span><span id="local-6989586621679055451"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055451"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679055450"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055450"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-var">Fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055452"><span class="hs-identifier hs-var">inp0</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.html#append"><span class="hs-operator hs-var">`B.append`</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055458"><span class="hs-identifier hs-var">inp</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055451"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055450"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-366"></span><span>
</span><span id="line-367"></span><span>
</span><span id="line-368"></span><span class="hs-comment">-- | Feed a 'Decoder' with more input. If the 'Decoder' is 'Done' or 'Fail' it</span><span>
</span><span id="line-369"></span><span class="hs-comment">-- will add the input to 'L.ByteString' of unconsumed input.</span><span>
</span><span id="line-370"></span><span class="hs-comment">--</span><span>
</span><span id="line-371"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-372"></span><span class="hs-comment">--    'runGetIncremental' myParser \`pushChunks\` myLazyByteString</span><span>
</span><span id="line-373"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-374"></span><span id="local-6989586621679055806"><span class="annot"><a href="Data.Binary.Get.html#pushChunks"><span class="hs-identifier hs-type">pushChunks</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055806"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055806"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-375"></span><span id="pushChunks"><span class="annot"><span class="annottext">pushChunks :: forall a. Decoder a -&gt; ByteString -&gt; Decoder a
</span><a href="Data.Binary.Get.html#pushChunks"><span class="hs-identifier hs-var hs-var">pushChunks</span></a></span></span><span> </span><span id="local-6989586621679055449"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055449"><span class="hs-identifier hs-var">r0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; [ByteString] -&gt; Decoder a
forall {a}. Decoder a -&gt; [ByteString] -&gt; Decoder a
</span><a href="#local-6989586621679055448"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055449"><span class="hs-identifier hs-var">r0</span></a></span><span> </span><span class="annot"><span class="annottext">([ByteString] -&gt; Decoder a)
-&gt; (ByteString -&gt; [ByteString]) -&gt; ByteString -&gt; Decoder a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; [ByteString]
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#toChunks"><span class="hs-identifier hs-var">L.toChunks</span></a></span><span>
</span><span id="line-376"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-377"></span><span>  </span><span id="local-6989586621679055448"><span class="annot"><span class="annottext">go :: Decoder a -&gt; [ByteString] -&gt; Decoder a
</span><a href="#local-6989586621679055448"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679055446"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055446"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055446"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-378"></span><span>  </span><span class="annot"><a href="#local-6989586621679055448"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span id="local-6989586621679055445"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055445"><span class="hs-identifier hs-var">inp</span></a></span></span><span> </span><span id="local-6989586621679055444"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055444"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055443"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055443"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055442"><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055442"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-var">Done</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.html#concat"><span class="hs-identifier hs-var">B.concat</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055445"><span class="hs-identifier hs-var">inp</span></a></span><span class="annot"><span class="annottext">ByteString -&gt; [ByteString] -&gt; [ByteString]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055442"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055444"><span class="hs-identifier hs-var">pos</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679055443"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-379"></span><span>  </span><span class="annot"><a href="#local-6989586621679055448"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span id="local-6989586621679055440"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055440"><span class="hs-identifier hs-var">inp</span></a></span></span><span> </span><span id="local-6989586621679055439"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055439"><span class="hs-identifier hs-var">pos</span></a></span></span><span> </span><span id="local-6989586621679055438"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055438"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679055437"><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055437"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
forall a. ByteString -&gt; Int64 -&gt; String -&gt; Decoder a
</span><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-var">Fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.html#concat"><span class="hs-identifier hs-var">B.concat</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055440"><span class="hs-identifier hs-var">inp</span></a></span><span class="annot"><span class="annottext">ByteString -&gt; [ByteString] -&gt; [ByteString]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055437"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055439"><span class="hs-identifier hs-var">pos</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679055438"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-380"></span><span>  </span><span class="annot"><a href="#local-6989586621679055448"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055436"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055436"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679055435"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055435"><span class="hs-identifier hs-var">x</span></a></span></span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span id="local-6989586621679055434"><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055434"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Decoder a -&gt; [ByteString] -&gt; Decoder a
</span><a href="#local-6989586621679055448"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055436"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Maybe ByteString
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055435"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[ByteString]
</span><a href="#local-6989586621679055434"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-381"></span><span>
</span><span id="line-382"></span><span class="hs-comment">-- | Tell a 'Decoder' that there is no more input. This passes 'Nothing' to a</span><span>
</span><span id="line-383"></span><span class="hs-comment">-- 'Partial' decoder, otherwise returns the decoder unchanged.</span><span>
</span><span id="line-384"></span><span id="local-6989586621679055803"><span class="annot"><a href="Data.Binary.Get.html#pushEndOfInput"><span class="hs-identifier hs-type">pushEndOfInput</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055803"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#Decoder"><span class="hs-identifier hs-type">Decoder</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055803"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-385"></span><span id="pushEndOfInput"><span class="annot"><span class="annottext">pushEndOfInput :: forall a. Decoder a -&gt; Decoder a
</span><a href="Data.Binary.Get.html#pushEndOfInput"><span class="hs-identifier hs-var hs-var">pushEndOfInput</span></a></span></span><span> </span><span id="local-6989586621679055433"><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055433"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-386"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055433"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-387"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Done"><span class="hs-identifier hs-type">Done</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055433"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-388"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Partial"><span class="hs-identifier hs-type">Partial</span></a></span><span> </span><span id="local-6989586621679055432"><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055432"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe ByteString -&gt; Decoder a
</span><a href="#local-6989586621679055432"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ByteString
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-389"></span><span>    </span><span class="annot"><a href="Data.Binary.Get.html#Fail"><span class="hs-identifier hs-type">Fail</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Decoder a
</span><a href="#local-6989586621679055433"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-390"></span><span>
</span><span id="line-391"></span><span class="hs-comment">-- | Skip ahead @n@ bytes. Fails if fewer than @n@ bytes are available.</span><span>
</span><span id="line-392"></span><span class="annot"><a href="Data.Binary.Get.html#skip"><span class="hs-identifier hs-type">skip</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-393"></span><span id="skip"><span class="annot"><span class="annottext">skip :: Int -&gt; Get ()
</span><a href="Data.Binary.Get.html#skip"><span class="hs-identifier hs-var hs-var">skip</span></a></span></span><span> </span><span id="local-6989586621679055431"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679055431"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64
-&gt; Consume Int64
-&gt; ([ByteString] -&gt; ())
-&gt; ([ByteString] -&gt; Get ())
-&gt; Get ()
forall s b.
s
-&gt; Consume s
-&gt; ([ByteString] -&gt; b)
-&gt; ([ByteString] -&gt; Get b)
-&gt; Get b
</span><a href="Data.Binary.Get.Internal.html#withInputChunks"><span class="hs-identifier hs-var">withInputChunks</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679055431"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Consume Int64
</span><a href="Data.Binary.Get.html#consumeBytes"><span class="hs-identifier hs-var">consumeBytes</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">() -&gt; [ByteString] -&gt; ()
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; Get ()
forall a. [ByteString] -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#failOnEOF"><span class="hs-identifier hs-var">failOnEOF</span></a></span><span>
</span><span id="line-394"></span><span>
</span><span id="line-395"></span><span class="hs-comment">-- | An efficient get method for lazy ByteStrings. Fails if fewer than @n@</span><span>
</span><span id="line-396"></span><span class="hs-comment">-- bytes are left in the input.</span><span>
</span><span id="line-397"></span><span class="annot"><a href="Data.Binary.Get.html#getLazyByteString"><span class="hs-identifier hs-type">getLazyByteString</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-398"></span><span id="getLazyByteString"><span class="annot"><span class="annottext">getLazyByteString :: Int64 -&gt; Get ByteString
</span><a href="Data.Binary.Get.html#getLazyByteString"><span class="hs-identifier hs-var hs-var">getLazyByteString</span></a></span></span><span> </span><span id="local-6989586621679055426"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055426"><span class="hs-identifier hs-var">n0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64
-&gt; Consume Int64
-&gt; ([ByteString] -&gt; ByteString)
-&gt; ([ByteString] -&gt; Get ByteString)
-&gt; Get ByteString
forall s b.
s
-&gt; Consume s
-&gt; ([ByteString] -&gt; b)
-&gt; ([ByteString] -&gt; Get b)
-&gt; Get b
</span><a href="Data.Binary.Get.Internal.html#withInputChunks"><span class="hs-identifier hs-var">withInputChunks</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055426"><span class="hs-identifier hs-var">n0</span></a></span><span> </span><span class="annot"><span class="annottext">Consume Int64
</span><a href="Data.Binary.Get.html#consumeBytes"><span class="hs-identifier hs-var">consumeBytes</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#fromChunks"><span class="hs-identifier hs-var">L.fromChunks</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; Get ByteString
forall a. [ByteString] -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#failOnEOF"><span class="hs-identifier hs-var">failOnEOF</span></a></span><span>
</span><span id="line-399"></span><span>
</span><span id="line-400"></span><span class="annot"><a href="Data.Binary.Get.html#consumeBytes"><span class="hs-identifier hs-type">consumeBytes</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Consume"><span class="hs-identifier hs-type">Consume</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>
</span><span id="line-401"></span><span id="consumeBytes"><span class="annot"><span class="annottext">consumeBytes :: Consume Int64
</span><a href="Data.Binary.Get.html#consumeBytes"><span class="hs-identifier hs-var hs-var">consumeBytes</span></a></span></span><span> </span><span id="local-6989586621679055424"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055424"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679055423"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055423"><span class="hs-identifier hs-var">str</span></a></span></span><span>
</span><span id="line-402"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055423"><span class="hs-identifier hs-var">str</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055424"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ByteString, ByteString) -&gt; Either Int64 (ByteString, ByteString)
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; ByteString -&gt; (ByteString, ByteString)
</span><a href="../../bytestring/src/Data.ByteString.html#splitAt"><span class="hs-identifier hs-var">B.splitAt</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055424"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055423"><span class="hs-identifier hs-var">str</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-403"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Either Int64 (ByteString, ByteString)
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679055424"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int64 -&gt; Int64
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055423"><span class="hs-identifier hs-var">str</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-404"></span><span>
</span><span id="line-405"></span><span class="annot"><a href="Data.Binary.Get.html#consumeUntilNul"><span class="hs-identifier hs-type">consumeUntilNul</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Consume"><span class="hs-identifier hs-type">Consume</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-406"></span><span id="consumeUntilNul"><span class="annot"><span class="annottext">consumeUntilNul :: Consume ()
</span><a href="Data.Binary.Get.html#consumeUntilNul"><span class="hs-identifier hs-var hs-var">consumeUntilNul</span></a></span></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679055420"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055420"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-407"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Bool) -&gt; ByteString -&gt; (ByteString, ByteString)
</span><a href="../../bytestring/src/Data.ByteString.html#break"><span class="hs-identifier hs-var">B.break</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word8 -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055420"><span class="hs-identifier hs-var">str</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-408"></span><span>    </span><span class="hs-special">(</span><span id="local-6989586621679055418"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055418"><span class="hs-identifier hs-var">want</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679055417"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055417"><span class="hs-identifier hs-var">rest</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Bool
</span><a href="../../bytestring/src/Data.ByteString.html#null"><span class="hs-identifier hs-var">B.null</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055417"><span class="hs-identifier hs-var">rest</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">() -&gt; Either () (ByteString, ByteString)
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-409"></span><span>                 </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(ByteString, ByteString) -&gt; Either () (ByteString, ByteString)
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055418"><span class="hs-identifier hs-var">want</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ByteString -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.html#drop"><span class="hs-identifier hs-var">B.drop</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055417"><span class="hs-identifier hs-var">rest</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-410"></span><span>
</span><span id="line-411"></span><span class="annot"><a href="Data.Binary.Get.html#consumeAll"><span class="hs-identifier hs-type">consumeAll</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Consume"><span class="hs-identifier hs-type">Consume</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-412"></span><span id="consumeAll"><span class="annot"><span class="annottext">consumeAll :: Consume ()
</span><a href="Data.Binary.Get.html#consumeAll"><span class="hs-identifier hs-var hs-var">consumeAll</span></a></span></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; Either () (ByteString, ByteString)
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-413"></span><span>
</span><span id="line-414"></span><span class="annot"><a href="Data.Binary.Get.html#resumeOnEOF"><span class="hs-identifier hs-type">resumeOnEOF</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-415"></span><span id="resumeOnEOF"><span class="annot"><span class="annottext">resumeOnEOF :: [ByteString] -&gt; Get ByteString
</span><a href="Data.Binary.Get.html#resumeOnEOF"><span class="hs-identifier hs-var hs-var">resumeOnEOF</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Get ByteString
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(ByteString -&gt; Get ByteString)
-&gt; ([ByteString] -&gt; ByteString) -&gt; [ByteString] -&gt; Get ByteString
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#fromChunks"><span class="hs-identifier hs-var">L.fromChunks</span></a></span><span>
</span><span id="line-416"></span><span>
</span><span id="line-417"></span><span class="hs-comment">-- | Get a lazy ByteString that is terminated with a NUL byte.</span><span>
</span><span id="line-418"></span><span class="hs-comment">-- The returned string does not contain the NUL byte. Fails</span><span>
</span><span id="line-419"></span><span class="hs-comment">-- if it reaches the end of input without finding a NUL.</span><span>
</span><span id="line-420"></span><span class="annot"><a href="Data.Binary.Get.html#getLazyByteStringNul"><span class="hs-identifier hs-type">getLazyByteStringNul</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-421"></span><span id="getLazyByteStringNul"><span class="annot"><span class="annottext">getLazyByteStringNul :: Get ByteString
</span><a href="Data.Binary.Get.html#getLazyByteStringNul"><span class="hs-identifier hs-var hs-var">getLazyByteStringNul</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">()
-&gt; Consume ()
-&gt; ([ByteString] -&gt; ByteString)
-&gt; ([ByteString] -&gt; Get ByteString)
-&gt; Get ByteString
forall s b.
s
-&gt; Consume s
-&gt; ([ByteString] -&gt; b)
-&gt; ([ByteString] -&gt; Get b)
-&gt; Get b
</span><a href="Data.Binary.Get.Internal.html#withInputChunks"><span class="hs-identifier hs-var">withInputChunks</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Consume ()
</span><a href="Data.Binary.Get.html#consumeUntilNul"><span class="hs-identifier hs-var">consumeUntilNul</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#fromChunks"><span class="hs-identifier hs-var">L.fromChunks</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; Get ByteString
forall a. [ByteString] -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#failOnEOF"><span class="hs-identifier hs-var">failOnEOF</span></a></span><span>
</span><span id="line-422"></span><span>
</span><span id="line-423"></span><span class="hs-comment">-- | Get the remaining bytes as a lazy ByteString.</span><span>
</span><span id="line-424"></span><span class="hs-comment">-- Note that this can be an expensive function to use as it forces reading</span><span>
</span><span id="line-425"></span><span class="hs-comment">-- all input and keeping the string in-memory.</span><span>
</span><span id="line-426"></span><span class="annot"><a href="Data.Binary.Get.html#getRemainingLazyByteString"><span class="hs-identifier hs-type">getRemainingLazyByteString</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">L.ByteString</span></a></span><span>
</span><span id="line-427"></span><span id="getRemainingLazyByteString"><span class="annot"><span class="annottext">getRemainingLazyByteString :: Get ByteString
</span><a href="Data.Binary.Get.html#getRemainingLazyByteString"><span class="hs-identifier hs-var hs-var">getRemainingLazyByteString</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">()
-&gt; Consume ()
-&gt; ([ByteString] -&gt; ByteString)
-&gt; ([ByteString] -&gt; Get ByteString)
-&gt; Get ByteString
forall s b.
s
-&gt; Consume s
-&gt; ([ByteString] -&gt; b)
-&gt; ([ByteString] -&gt; Get b)
-&gt; Get b
</span><a href="Data.Binary.Get.Internal.html#withInputChunks"><span class="hs-identifier hs-var">withInputChunks</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Consume ()
</span><a href="Data.Binary.Get.html#consumeAll"><span class="hs-identifier hs-var">consumeAll</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; ByteString
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#fromChunks"><span class="hs-identifier hs-var">L.fromChunks</span></a></span><span> </span><span class="annot"><span class="annottext">[ByteString] -&gt; Get ByteString
</span><a href="Data.Binary.Get.html#resumeOnEOF"><span class="hs-identifier hs-var">resumeOnEOF</span></a></span><span>
</span><span id="line-428"></span><span>
</span><span id="line-429"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-430"></span><span class="hs-comment">-- Primtives</span><span>
</span><span id="line-431"></span><span>
</span><span id="line-432"></span><span class="hs-comment">-- helper, get a raw Ptr onto a strict ByteString copied out of the</span><span>
</span><span id="line-433"></span><span class="hs-comment">-- underlying lazy byteString.</span><span>
</span><span id="line-434"></span><span>
</span><span id="line-435"></span><span id="local-6989586621679055791"><span class="annot"><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-type">getPtr</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055791"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679055791"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-436"></span><span id="getPtr"><span class="annot"><span class="annottext">getPtr :: forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var hs-var">getPtr</span></a></span></span><span> </span><span id="local-6989586621679055409"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679055409"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (Ptr a -&gt; IO a) -&gt; Get a
forall a. Int -&gt; (Ptr a -&gt; IO a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readNWith"><span class="hs-identifier hs-var">readNWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679055409"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; IO a
forall a. Storable a =&gt; Ptr a -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peek"><span class="hs-identifier hs-var">peek</span></a></span><span>
</span><span id="line-437"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getPtr"><span class="hs-pragma hs-type">getPtr</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-438"></span><span>
</span><span id="line-439"></span><span class="hs-comment">-- | Read a Word8 from the monad state</span><span>
</span><span id="line-440"></span><span class="annot"><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-type">getWord8</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-441"></span><span id="getWord8"><span class="annot"><span class="annottext">getWord8 :: Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var hs-var">getWord8</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word8) -&gt; Get Word8
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeHead"><span class="hs-identifier hs-var">B.unsafeHead</span></a></span><span>
</span><span id="line-442"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord8"><span class="hs-pragma hs-type">getWord8</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-443"></span><span>
</span><span id="line-444"></span><span class="hs-comment">-- | Read an Int8 from the monad state</span><span>
</span><span id="line-445"></span><span class="annot"><a href="Data.Binary.Get.html#getInt8"><span class="hs-identifier hs-type">getInt8</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-identifier hs-type">Int8</span></a></span><span>
</span><span id="line-446"></span><span id="getInt8"><span class="annot"><span class="annottext">getInt8 :: Get Int8
</span><a href="Data.Binary.Get.html#getInt8"><span class="hs-identifier hs-var hs-var">getInt8</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Int8) -&gt; Get Word8 -&gt; Get Int8
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-447"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt8"><span class="hs-pragma hs-type">getInt8</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-448"></span><span>
</span><span id="line-449"></span><span>
</span><span id="line-450"></span><span class="hs-comment">-- force GHC to inline getWordXX</span><span>
</span><span id="line-451"></span><span class="hs-pragma">{-# RULES</span><span>
</span><span id="line-452"></span><span class="annot"><span class="hs-pragma">&quot;getWord8/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord8"><span class="hs-pragma hs-type">getWord8</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">1</span></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeHead"><span class="hs-pragma hs-type">B.unsafeHead</span></a></span><span>
</span><span id="line-453"></span><span class="annot"><span class="hs-pragma">&quot;getWord16be/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16be"><span class="hs-pragma hs-type">getWord16be</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">2</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word16be"><span class="hs-pragma hs-type">word16be</span></a></span><span>
</span><span id="line-454"></span><span class="annot"><span class="hs-pragma">&quot;getWord16le/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16le"><span class="hs-pragma hs-type">getWord16le</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">2</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word16le"><span class="hs-pragma hs-type">word16le</span></a></span><span>
</span><span id="line-455"></span><span class="annot"><span class="hs-pragma">&quot;getWord32be/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32be"><span class="hs-pragma hs-type">getWord32be</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">4</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word32be"><span class="hs-pragma hs-type">word32be</span></a></span><span>
</span><span id="line-456"></span><span class="annot"><span class="hs-pragma">&quot;getWord32le/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32le"><span class="hs-pragma hs-type">getWord32le</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">4</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word32le"><span class="hs-pragma hs-type">word32le</span></a></span><span>
</span><span id="line-457"></span><span class="annot"><span class="hs-pragma">&quot;getWord64be/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64be"><span class="hs-pragma hs-type">getWord64be</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">8</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word64be"><span class="hs-pragma hs-type">word64be</span></a></span><span>
</span><span id="line-458"></span><span class="annot"><span class="hs-pragma">&quot;getWord64le/readN&quot;</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64le"><span class="hs-pragma hs-type">getWord64le</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-pragma hs-type">readN</span></a></span><span> </span><span class="annot"><span class="hs-pragma">8</span></span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word64le"><span class="hs-pragma hs-type">word64le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span class="hs-comment">-- | Read a Word16 in big endian format</span><span>
</span><span id="line-461"></span><span class="annot"><a href="Data.Binary.Get.html#getWord16be"><span class="hs-identifier hs-type">getWord16be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-462"></span><span id="getWord16be"><span class="annot"><span class="annottext">getWord16be :: Get Word16
</span><a href="Data.Binary.Get.html#getWord16be"><span class="hs-identifier hs-var hs-var">getWord16be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word16) -&gt; Get Word16
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word16
</span><a href="Data.Binary.Get.html#word16be"><span class="hs-identifier hs-var">word16be</span></a></span><span>
</span><span id="line-463"></span><span>
</span><span id="line-464"></span><span class="annot"><a href="Data.Binary.Get.html#word16be"><span class="hs-identifier hs-type">word16be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-465"></span><span id="word16be"><span class="annot"><span class="annottext">word16be :: ByteString -&gt; Word16
</span><a href="Data.Binary.Get.html#word16be"><span class="hs-identifier hs-var hs-var">word16be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055397"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055397"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-466"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055397"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int -&gt; Word16
</span><a href="Data.Binary.Get.html#shiftl_w16"><span class="hs-operator hs-var">`shiftl_w16`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16 -&gt; Word16
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-467"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055397"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-468"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16be"><span class="hs-pragma hs-type">getWord16be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-469"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word16be"><span class="hs-pragma hs-type">word16be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-470"></span><span>
</span><span id="line-471"></span><span class="hs-comment">-- | Read a Word16 in little endian format</span><span>
</span><span id="line-472"></span><span class="annot"><a href="Data.Binary.Get.html#getWord16le"><span class="hs-identifier hs-type">getWord16le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-473"></span><span id="getWord16le"><span class="annot"><span class="annottext">getWord16le :: Get Word16
</span><a href="Data.Binary.Get.html#getWord16le"><span class="hs-identifier hs-var hs-var">getWord16le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word16) -&gt; Get Word16
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word16
</span><a href="Data.Binary.Get.html#word16le"><span class="hs-identifier hs-var">word16le</span></a></span><span>
</span><span id="line-474"></span><span>
</span><span id="line-475"></span><span class="annot"><a href="Data.Binary.Get.html#word16le"><span class="hs-identifier hs-type">word16le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-476"></span><span id="word16le"><span class="annot"><span class="annottext">word16le :: ByteString -&gt; Word16
</span><a href="Data.Binary.Get.html#word16le"><span class="hs-identifier hs-var hs-var">word16le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055393"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055393"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-477"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055393"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int -&gt; Word16
</span><a href="Data.Binary.Get.html#shiftl_w16"><span class="hs-operator hs-var">`shiftl_w16`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16 -&gt; Word16
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-478"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055393"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-479"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16le"><span class="hs-pragma hs-type">getWord16le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-480"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word16le"><span class="hs-pragma hs-type">word16le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-481"></span><span>
</span><span id="line-482"></span><span class="hs-comment">-- | Read a Word32 in big endian format</span><span>
</span><span id="line-483"></span><span class="annot"><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier hs-type">getWord32be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-484"></span><span id="getWord32be"><span class="annot"><span class="annottext">getWord32be :: Get Word32
</span><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier hs-var hs-var">getWord32be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word32) -&gt; Get Word32
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word32
</span><a href="Data.Binary.Get.html#word32be"><span class="hs-identifier hs-var">word32be</span></a></span><span>
</span><span id="line-485"></span><span>
</span><span id="line-486"></span><span class="annot"><a href="Data.Binary.Get.html#word32be"><span class="hs-identifier hs-type">word32be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-487"></span><span id="word32be"><span class="annot"><span class="annottext">word32be :: ByteString -&gt; Word32
</span><a href="Data.Binary.Get.html#word32be"><span class="hs-identifier hs-var hs-var">word32be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055392"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055392"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-488"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055392"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-489"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055392"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-490"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055392"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-491"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055392"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-492"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32be"><span class="hs-pragma hs-type">getWord32be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-493"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word32be"><span class="hs-pragma hs-type">word32be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-494"></span><span>
</span><span id="line-495"></span><span class="hs-comment">-- | Read a Word32 in little endian format</span><span>
</span><span id="line-496"></span><span class="annot"><a href="Data.Binary.Get.html#getWord32le"><span class="hs-identifier hs-type">getWord32le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-497"></span><span id="getWord32le"><span class="annot"><span class="annottext">getWord32le :: Get Word32
</span><a href="Data.Binary.Get.html#getWord32le"><span class="hs-identifier hs-var hs-var">getWord32le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word32) -&gt; Get Word32
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word32
</span><a href="Data.Binary.Get.html#word32le"><span class="hs-identifier hs-var">word32le</span></a></span><span>
</span><span id="line-498"></span><span>
</span><span id="line-499"></span><span class="annot"><a href="Data.Binary.Get.html#word32le"><span class="hs-identifier hs-type">word32le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-500"></span><span id="word32le"><span class="annot"><span class="annottext">word32le :: ByteString -&gt; Word32
</span><a href="Data.Binary.Get.html#word32le"><span class="hs-identifier hs-var hs-var">word32le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055390"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055390"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-501"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055390"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-502"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055390"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-503"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055390"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-operator hs-var">`shiftl_w32`</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-504"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055390"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-505"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32le"><span class="hs-pragma hs-type">getWord32le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-506"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word32le"><span class="hs-pragma hs-type">word32le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-507"></span><span>
</span><span id="line-508"></span><span class="hs-comment">-- | Read a Word64 in big endian format</span><span>
</span><span id="line-509"></span><span class="annot"><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-type">getWord64be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-510"></span><span id="getWord64be"><span class="annot"><span class="annottext">getWord64be :: Get Word64
</span><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-var hs-var">getWord64be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word64) -&gt; Get Word64
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word64
</span><a href="Data.Binary.Get.html#word64be"><span class="hs-identifier hs-var">word64be</span></a></span><span>
</span><span id="line-511"></span><span>
</span><span id="line-512"></span><span class="annot"><a href="Data.Binary.Get.html#word64be"><span class="hs-identifier hs-type">word64be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-513"></span><span id="word64be"><span class="annot"><span class="annottext">word64be :: ByteString -&gt; Word64
</span><a href="Data.Binary.Get.html#word64be"><span class="hs-identifier hs-var hs-var">word64be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055389"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-514"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">56</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-515"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">48</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-516"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">40</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-517"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">32</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-518"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-519"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-520"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-521"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055389"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-522"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64be"><span class="hs-pragma hs-type">getWord64be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-523"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word64be"><span class="hs-pragma hs-type">word64be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-524"></span><span>
</span><span id="line-525"></span><span class="hs-comment">-- | Read a Word64 in little endian format</span><span>
</span><span id="line-526"></span><span class="annot"><a href="Data.Binary.Get.html#getWord64le"><span class="hs-identifier hs-type">getWord64le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-527"></span><span id="getWord64le"><span class="annot"><span class="annottext">getWord64le :: Get Word64
</span><a href="Data.Binary.Get.html#getWord64le"><span class="hs-identifier hs-var hs-var">getWord64le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; (ByteString -&gt; Word64) -&gt; Get Word64
forall a. Int -&gt; (ByteString -&gt; a) -&gt; Get a
</span><a href="Data.Binary.Get.Internal.html#readN"><span class="hs-identifier hs-var">readN</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Word64
</span><a href="Data.Binary.Get.html#word64le"><span class="hs-identifier hs-var">word64le</span></a></span><span>
</span><span id="line-528"></span><span>
</span><span id="line-529"></span><span class="annot"><a href="Data.Binary.Get.html#word64le"><span class="hs-identifier hs-type">word64le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-530"></span><span id="word64le"><span class="annot"><span class="annottext">word64le :: ByteString -&gt; Word64
</span><a href="Data.Binary.Get.html#word64le"><span class="hs-identifier hs-var hs-var">word64le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679055387"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-531"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">56</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-532"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">48</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-533"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">40</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-534"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">32</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-535"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-536"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-537"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-operator hs-var">`shiftl_w64`</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-538"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679055387"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Int -&gt; Word8
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeIndex"><span class="hs-operator hs-var">`B.unsafeIndex`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-539"></span><span class="hs-pragma">{-# INLINE</span><span class="hs-pragma">[</span><span class="hs-pragma">2</span><span class="hs-pragma">]</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64le"><span class="hs-pragma hs-type">getWord64le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-540"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#word64le"><span class="hs-pragma hs-type">word64le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-541"></span><span>
</span><span id="line-542"></span><span>
</span><span id="line-543"></span><span class="hs-comment">-- | Read an Int16 in big endian format.</span><span>
</span><span id="line-544"></span><span class="annot"><a href="Data.Binary.Get.html#getInt16be"><span class="hs-identifier hs-type">getInt16be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span>
</span><span id="line-545"></span><span id="getInt16be"><span class="annot"><span class="annottext">getInt16be :: Get Int16
</span><a href="Data.Binary.Get.html#getInt16be"><span class="hs-identifier hs-var hs-var">getInt16be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; Int16) -&gt; Get Word16 -&gt; Get Int16
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word16
</span><a href="Data.Binary.Get.html#getWord16be"><span class="hs-identifier hs-var">getWord16be</span></a></span><span>
</span><span id="line-546"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16be"><span class="hs-pragma hs-type">getInt16be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-547"></span><span>
</span><span id="line-548"></span><span class="hs-comment">-- | Read an Int32 in big endian format.</span><span>
</span><span id="line-549"></span><span class="annot"><a href="Data.Binary.Get.html#getInt32be"><span class="hs-identifier hs-type">getInt32be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span>
</span><span id="line-550"></span><span id="getInt32be"><span class="annot"><span class="annottext">getInt32be :: Get Int32
</span><a href="Data.Binary.Get.html#getInt32be"><span class="hs-identifier hs-var hs-var">getInt32be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>  </span><span class="annot"><span class="annottext">Word32 -&gt; Int32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; Int32) -&gt; Get Word32 -&gt; Get Int32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier hs-var">getWord32be</span></a></span><span>
</span><span id="line-551"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32be"><span class="hs-pragma hs-type">getInt32be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-552"></span><span>
</span><span id="line-553"></span><span class="hs-comment">-- | Read an Int64 in big endian format.</span><span>
</span><span id="line-554"></span><span class="annot"><a href="Data.Binary.Get.html#getInt64be"><span class="hs-identifier hs-type">getInt64be</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>
</span><span id="line-555"></span><span id="getInt64be"><span class="annot"><span class="annottext">getInt64be :: Get Int64
</span><a href="Data.Binary.Get.html#getInt64be"><span class="hs-identifier hs-var hs-var">getInt64be</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Int64) -&gt; Get Word64 -&gt; Get Int64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-var">getWord64be</span></a></span><span>
</span><span id="line-556"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64be"><span class="hs-pragma hs-type">getInt64be</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-557"></span><span>
</span><span id="line-558"></span><span>
</span><span id="line-559"></span><span class="hs-comment">-- | Read an Int16 in little endian format.</span><span>
</span><span id="line-560"></span><span class="annot"><a href="Data.Binary.Get.html#getInt16le"><span class="hs-identifier hs-type">getInt16le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span>
</span><span id="line-561"></span><span id="getInt16le"><span class="annot"><span class="annottext">getInt16le :: Get Int16
</span><a href="Data.Binary.Get.html#getInt16le"><span class="hs-identifier hs-var hs-var">getInt16le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; Int16) -&gt; Get Word16 -&gt; Get Int16
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word16
</span><a href="Data.Binary.Get.html#getWord16le"><span class="hs-identifier hs-var">getWord16le</span></a></span><span>
</span><span id="line-562"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16le"><span class="hs-pragma hs-type">getInt16le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-563"></span><span>
</span><span id="line-564"></span><span class="hs-comment">-- | Read an Int32 in little endian format.</span><span>
</span><span id="line-565"></span><span class="annot"><a href="Data.Binary.Get.html#getInt32le"><span class="hs-identifier hs-type">getInt32le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span>
</span><span id="line-566"></span><span id="getInt32le"><span class="annot"><span class="annottext">getInt32le :: Get Int32
</span><a href="Data.Binary.Get.html#getInt32le"><span class="hs-identifier hs-var hs-var">getInt32le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>  </span><span class="annot"><span class="annottext">Word32 -&gt; Int32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; Int32) -&gt; Get Word32 -&gt; Get Int32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32le"><span class="hs-identifier hs-var">getWord32le</span></a></span><span>
</span><span id="line-567"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32le"><span class="hs-pragma hs-type">getInt32le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-568"></span><span>
</span><span id="line-569"></span><span class="hs-comment">-- | Read an Int64 in little endian format.</span><span>
</span><span id="line-570"></span><span class="annot"><a href="Data.Binary.Get.html#getInt64le"><span class="hs-identifier hs-type">getInt64le</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>
</span><span id="line-571"></span><span id="getInt64le"><span class="annot"><span class="annottext">getInt64le :: Get Int64
</span><a href="Data.Binary.Get.html#getInt64le"><span class="hs-identifier hs-var hs-var">getInt64le</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Int64) -&gt; Get Word64 -&gt; Get Int64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64le"><span class="hs-identifier hs-var">getWord64le</span></a></span><span>
</span><span id="line-572"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64le"><span class="hs-pragma hs-type">getInt64le</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-573"></span><span>
</span><span id="line-574"></span><span>
</span><span id="line-575"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-576"></span><span class="hs-comment">-- Host-endian reads</span><span>
</span><span id="line-577"></span><span>
</span><span id="line-578"></span><span class="hs-comment">-- | /O(1)./ Read a single native machine word. The word is read in</span><span>
</span><span id="line-579"></span><span class="hs-comment">-- host order, host endian form, for the machine you're on. On a 64 bit</span><span>
</span><span id="line-580"></span><span class="hs-comment">-- machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes.</span><span>
</span><span id="line-581"></span><span class="annot"><a href="Data.Binary.Get.html#getWordhost"><span class="hs-identifier hs-type">getWordhost</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span>
</span><span id="line-582"></span><span id="getWordhost"><span class="annot"><span class="annottext">getWordhost :: Get Word
</span><a href="Data.Binary.Get.html#getWordhost"><span class="hs-identifier hs-var hs-var">getWordhost</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Word
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-583"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWordhost"><span class="hs-pragma hs-type">getWordhost</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-584"></span><span>
</span><span id="line-585"></span><span class="hs-comment">-- | /O(1)./ Read a 2 byte Word16 in native host order and host endianness.</span><span>
</span><span id="line-586"></span><span class="annot"><a href="Data.Binary.Get.html#getWord16host"><span class="hs-identifier hs-type">getWord16host</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-587"></span><span id="getWord16host"><span class="annot"><span class="annottext">getWord16host :: Get Word16
</span><a href="Data.Binary.Get.html#getWord16host"><span class="hs-identifier hs-var hs-var">getWord16host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Word16
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-588"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord16host"><span class="hs-pragma hs-type">getWord16host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-589"></span><span>
</span><span id="line-590"></span><span class="hs-comment">-- | /O(1)./ Read a Word32 in native host order and host endianness.</span><span>
</span><span id="line-591"></span><span class="annot"><a href="Data.Binary.Get.html#getWord32host"><span class="hs-identifier hs-type">getWord32host</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-592"></span><span id="getWord32host"><span class="annot"><span class="annottext">getWord32host :: Get Word32
</span><a href="Data.Binary.Get.html#getWord32host"><span class="hs-identifier hs-var hs-var">getWord32host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Word32
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-593"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord32host"><span class="hs-pragma hs-type">getWord32host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-594"></span><span>
</span><span id="line-595"></span><span class="hs-comment">-- | /O(1)./ Read a Word64 in native host order and host endianess.</span><span>
</span><span id="line-596"></span><span class="annot"><a href="Data.Binary.Get.html#getWord64host"><span class="hs-identifier hs-type">getWord64host</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-597"></span><span id="getWord64host"><span class="annot"><span class="annottext">getWord64host :: Get Word64
</span><a href="Data.Binary.Get.html#getWord64host"><span class="hs-identifier hs-var hs-var">getWord64host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Word64
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-598"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getWord64host"><span class="hs-pragma hs-type">getWord64host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-599"></span><span>
</span><span id="line-600"></span><span class="hs-comment">-- | /O(1)./ Read a single native machine word in native host</span><span>
</span><span id="line-601"></span><span class="hs-comment">-- order. It works in the same way as 'getWordhost'.</span><span>
</span><span id="line-602"></span><span class="annot"><a href="Data.Binary.Get.html#getInthost"><span class="hs-identifier hs-type">getInthost</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-603"></span><span id="getInthost"><span class="annot"><span class="annottext">getInthost :: Get Int
</span><a href="Data.Binary.Get.html#getInthost"><span class="hs-identifier hs-var hs-var">getInthost</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Int
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-604"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInthost"><span class="hs-pragma hs-type">getInthost</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-605"></span><span>
</span><span id="line-606"></span><span class="hs-comment">-- | /O(1)./ Read a 2 byte Int16 in native host order and host endianness.</span><span>
</span><span id="line-607"></span><span class="annot"><a href="Data.Binary.Get.html#getInt16host"><span class="hs-identifier hs-type">getInt16host</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span>
</span><span id="line-608"></span><span id="getInt16host"><span class="annot"><span class="annottext">getInt16host :: Get Int16
</span><a href="Data.Binary.Get.html#getInt16host"><span class="hs-identifier hs-var hs-var">getInt16host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Int16
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int16 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int16
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-609"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt16host"><span class="hs-pragma hs-type">getInt16host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-610"></span><span>
</span><span id="line-611"></span><span class="hs-comment">-- | /O(1)./ Read an Int32 in native host order and host endianness.</span><span>
</span><span id="line-612"></span><span class="annot"><a href="Data.Binary.Get.html#getInt32host"><span class="hs-identifier hs-type">getInt32host</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span>
</span><span id="line-613"></span><span id="getInt32host"><span class="annot"><span class="annottext">getInt32host :: Get Int32
</span><a href="Data.Binary.Get.html#getInt32host"><span class="hs-identifier hs-var hs-var">getInt32host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Int32
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-614"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt32host"><span class="hs-pragma hs-type">getInt32host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-615"></span><span>
</span><span id="line-616"></span><span class="hs-comment">-- | /O(1)./ Read an Int64 in native host order and host endianess.</span><span>
</span><span id="line-617"></span><span class="annot"><a href="Data.Binary.Get.html#getInt64host"><span class="hs-identifier hs-type">getInt64host</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span>
</span><span id="line-618"></span><span id="getInt64host"><span class="annot"><span class="annottext">getInt64host :: Get Int64
</span><a href="Data.Binary.Get.html#getInt64host"><span class="hs-identifier hs-var hs-var">getInt64host</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Int64
forall a. Storable a =&gt; Int -&gt; Get a
</span><a href="Data.Binary.Get.html#getPtr"><span class="hs-identifier hs-var">getPtr</span></a></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="../../base/src/Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
forall a. HasCallStack =&gt; a
</span><a href="../../base/src/GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-619"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getInt64host"><span class="hs-pragma hs-type">getInt64host</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-620"></span><span>
</span><span id="line-621"></span><span>
</span><span id="line-622"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-623"></span><span class="hs-comment">-- Double/Float reads</span><span>
</span><span id="line-624"></span><span>
</span><span id="line-625"></span><span class="hs-comment">-- | Read a 'Float' in big endian IEEE-754 format.</span><span>
</span><span id="line-626"></span><span class="annot"><a href="Data.Binary.Get.html#getFloatbe"><span class="hs-identifier hs-type">getFloatbe</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span><span>
</span><span id="line-627"></span><span id="getFloatbe"><span class="annot"><span class="annottext">getFloatbe :: Get Float
</span><a href="Data.Binary.Get.html#getFloatbe"><span class="hs-identifier hs-var hs-var">getFloatbe</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Float
</span><a href="Data.Binary.FloatCast.html#wordToFloat"><span class="hs-identifier hs-var">wordToFloat</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; Float) -&gt; Get Word32 -&gt; Get Float
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier hs-var">getWord32be</span></a></span><span>
</span><span id="line-628"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloatbe"><span class="hs-pragma hs-type">getFloatbe</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-629"></span><span>
</span><span id="line-630"></span><span class="hs-comment">-- | Read a 'Float' in little endian IEEE-754 format.</span><span>
</span><span id="line-631"></span><span class="annot"><a href="Data.Binary.Get.html#getFloatle"><span class="hs-identifier hs-type">getFloatle</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span><span>
</span><span id="line-632"></span><span id="getFloatle"><span class="annot"><span class="annottext">getFloatle :: Get Float
</span><a href="Data.Binary.Get.html#getFloatle"><span class="hs-identifier hs-var hs-var">getFloatle</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Float
</span><a href="Data.Binary.FloatCast.html#wordToFloat"><span class="hs-identifier hs-var">wordToFloat</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; Float) -&gt; Get Word32 -&gt; Get Float
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32le"><span class="hs-identifier hs-var">getWord32le</span></a></span><span>
</span><span id="line-633"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloatle"><span class="hs-pragma hs-type">getFloatle</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-634"></span><span>
</span><span id="line-635"></span><span class="hs-comment">-- | Read a 'Float' in IEEE-754 format and host endian.</span><span>
</span><span id="line-636"></span><span class="annot"><a href="Data.Binary.Get.html#getFloathost"><span class="hs-identifier hs-type">getFloathost</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span><span>
</span><span id="line-637"></span><span id="getFloathost"><span class="annot"><span class="annottext">getFloathost :: Get Float
</span><a href="Data.Binary.Get.html#getFloathost"><span class="hs-identifier hs-var hs-var">getFloathost</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Float
</span><a href="Data.Binary.FloatCast.html#wordToFloat"><span class="hs-identifier hs-var">wordToFloat</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; Float) -&gt; Get Word32 -&gt; Get Float
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32host"><span class="hs-identifier hs-var">getWord32host</span></a></span><span>
</span><span id="line-638"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getFloathost"><span class="hs-pragma hs-type">getFloathost</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-639"></span><span>
</span><span id="line-640"></span><span class="hs-comment">-- | Read a 'Double' in big endian IEEE-754 format.</span><span>
</span><span id="line-641"></span><span class="annot"><a href="Data.Binary.Get.html#getDoublebe"><span class="hs-identifier hs-type">getDoublebe</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span>
</span><span id="line-642"></span><span id="getDoublebe"><span class="annot"><span class="annottext">getDoublebe :: Get Double
</span><a href="Data.Binary.Get.html#getDoublebe"><span class="hs-identifier hs-var hs-var">getDoublebe</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Double
</span><a href="Data.Binary.FloatCast.html#wordToDouble"><span class="hs-identifier hs-var">wordToDouble</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Double) -&gt; Get Word64 -&gt; Get Double
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-var">getWord64be</span></a></span><span>
</span><span id="line-643"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublebe"><span class="hs-pragma hs-type">getDoublebe</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-644"></span><span>
</span><span id="line-645"></span><span class="hs-comment">-- | Read a 'Double' in little endian IEEE-754 format.</span><span>
</span><span id="line-646"></span><span class="annot"><a href="Data.Binary.Get.html#getDoublele"><span class="hs-identifier hs-type">getDoublele</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span>
</span><span id="line-647"></span><span id="getDoublele"><span class="annot"><span class="annottext">getDoublele :: Get Double
</span><a href="Data.Binary.Get.html#getDoublele"><span class="hs-identifier hs-var hs-var">getDoublele</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Double
</span><a href="Data.Binary.FloatCast.html#wordToDouble"><span class="hs-identifier hs-var">wordToDouble</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Double) -&gt; Get Word64 -&gt; Get Double
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64le"><span class="hs-identifier hs-var">getWord64le</span></a></span><span>
</span><span id="line-648"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublele"><span class="hs-pragma hs-type">getDoublele</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-649"></span><span>
</span><span id="line-650"></span><span class="hs-comment">-- | Read a 'Double' in IEEE-754 format and host endian.</span><span>
</span><span id="line-651"></span><span class="annot"><a href="Data.Binary.Get.html#getDoublehost"><span class="hs-identifier hs-type">getDoublehost</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span>
</span><span id="line-652"></span><span id="getDoublehost"><span class="annot"><span class="annottext">getDoublehost :: Get Double
</span><a href="Data.Binary.Get.html#getDoublehost"><span class="hs-identifier hs-var hs-var">getDoublehost</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Double
</span><a href="Data.Binary.FloatCast.html#wordToDouble"><span class="hs-identifier hs-var">wordToDouble</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Double) -&gt; Get Word64 -&gt; Get Double
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64host"><span class="hs-identifier hs-var">getWord64host</span></a></span><span>
</span><span id="line-653"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Get.html#getDoublehost"><span class="hs-pragma hs-type">getDoublehost</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-654"></span><span>
</span><span id="line-655"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-656"></span><span class="hs-comment">-- Unchecked shifts</span><span>
</span><span id="line-657"></span><span>
</span><span id="line-658"></span><span class="annot"><a href="Data.Binary.Get.html#shiftl_w16"><span class="hs-identifier hs-type">shiftl_w16</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-659"></span><span class="annot"><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-identifier hs-type">shiftl_w32</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-660"></span><span class="annot"><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-identifier hs-type">shiftl_w64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span class="hs-cpp">

#if defined(__GLASGOW_HASKELL__) &amp;&amp; !defined(__HADDOCK__)
</span><span id="shiftl_w16"><span class="annot"><span class="annottext">shiftl_w16 :: Word16 -&gt; Int -&gt; Word16
</span><a href="Data.Binary.Get.html#shiftl_w16"><span class="hs-identifier hs-var hs-var">shiftl_w16</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Word.html#W16%23"><span class="hs-identifier hs-type">W16#</span></a></span><span> </span><span id="local-6989586621679055383"><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055383"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">I#</span></span><span> </span><span id="local-6989586621679055382"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055382"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Word16
</span><a href="../../base/src/GHC.Word.html#W16%23"><span class="hs-identifier hs-var">W16#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055383"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Int# -&gt; Word#
</span><span class="hs-operator hs-var">`uncheckedShiftL#`</span></span><span>   </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055382"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-664"></span><span id="shiftl_w32"><span class="annot"><span class="annottext">shiftl_w32 :: Word32 -&gt; Int -&gt; Word32
</span><a href="Data.Binary.Get.html#shiftl_w32"><span class="hs-identifier hs-var hs-var">shiftl_w32</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Word.html#W32%23"><span class="hs-identifier hs-type">W32#</span></a></span><span> </span><span id="local-6989586621679055380"><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055380"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">I#</span></span><span> </span><span id="local-6989586621679055379"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055379"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Word32
</span><a href="../../base/src/GHC.Word.html#W32%23"><span class="hs-identifier hs-var">W32#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055380"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Int# -&gt; Word#
</span><span class="hs-operator hs-var">`uncheckedShiftL#`</span></span><span>   </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055379"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span class="hs-cpp">

#if WORD_SIZE_IN_BITS &lt; 64
</span><span class="hs-identifier">shiftl_w64</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">W64#</span><span> </span><span class="hs-identifier">w</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">I#</span><span> </span><span class="hs-identifier">i</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">W64#</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">w</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">uncheckedShiftL64#</span><span class="hs-special">`</span><span> </span><span class="hs-identifier">i</span><span class="hs-special">)</span><span class="hs-cpp">

#else
</span><span id="shiftl_w64"><span class="annot"><span class="annottext">shiftl_w64 :: Word64 -&gt; Int -&gt; Word64
</span><a href="Data.Binary.Get.html#shiftl_w64"><span class="hs-identifier hs-var hs-var">shiftl_w64</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Word.html#W64%23"><span class="hs-identifier hs-type">W64#</span></a></span><span> </span><span id="local-6989586621679055377"><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055377"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">I#</span></span><span> </span><span id="local-6989586621679055376"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055376"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Word64
</span><a href="../../base/src/GHC.Word.html#W64%23"><span class="hs-identifier hs-var">W64#</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word#
</span><a href="#local-6989586621679055377"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word# -&gt; Int# -&gt; Word#
</span><span class="hs-operator hs-var">`uncheckedShiftL#`</span></span><span> </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679055376"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#else
</span><span class="hs-identifier">shiftl_w16</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">shiftL</span><span>
</span><span id="line-675"></span><span class="hs-identifier">shiftl_w32</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">shiftL</span><span>
</span><span id="line-676"></span><span class="hs-identifier">shiftl_w64</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">shiftL</span><span class="hs-cpp">
#endif
</span></pre></body></html>